package com.melody.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.melody.entry.MusicInfo;
import com.melody.entry.PlaylistInfo;
import com.melody.entry.PlaylistMusic;
import com.melody.entry.Result;
import com.melody.service.PlaylistMusicService;
import com.melody.mapper.PlaylistMusicMapper;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
 * PlaylistMusicServiceImpl类实现了PlaylistMusicService接口，负责对歌单·歌曲表（playlist_music）进行数据库操作。
 * @author zxz
 * @description 针对表【playlist_music(歌单·歌曲表)】的数据库操作Service实现
 * @createDate 2025-05-09 10:31:18
 */
@Service
public class PlaylistMusicServiceImpl extends ServiceImpl<PlaylistMusicMapper, PlaylistMusic> implements PlaylistMusicService {
    @Autowired
    private PlaylistMusicMapper playlistMusicMapper; // 注入PlaylistMusicMapper

    /**
     * 向歌单添加音乐。
     * @param playlistMusic 歌单音乐信息
     * @return PlaylistMusic 添加成功的歌单音乐信息
     */
    @Override
    public PlaylistMusic addMusicToPlaylist(PlaylistMusic playlistMusic) {
        // 构建查询条件，检查是否已经存在相同的歌单音乐信息
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("music_id", playlistMusic.getMusicId())
                .eq("list_id", playlistMusic.getListId());
        int existingCount = Math.toIntExact(playlistMusicMapper.selectCount(queryWrapper));

        if (existingCount > 0) {
            // 如果已经存在相同的歌单音乐信息，则不重复添加
            return null;
        }

        // 保存歌单音乐信息
        save(playlistMusic);

        LocalDateTime now = LocalDateTime.now(); // 获取当前时间

        // 查询当前list_id对应的最大sort_order值
        QueryWrapper<PlaylistMusic> sortQueryWrapper = new QueryWrapper<>();
        sortQueryWrapper.select("MAX(sort_order) as maxSortOrder")
                .eq("list_id", playlistMusic.getListId());
        List<Map<String, Object>> maxSortOrderList = playlistMusicMapper.selectMaps(sortQueryWrapper);

        Integer maxSortOrder = Optional.ofNullable(maxSortOrderList)
                .orElseGet(Collections::emptyList)
                .stream()
                .findFirst()
                .map(map -> (Integer) map.get("maxSortOrder"))
                .orElse(0);

        // 设置新的sort_order值
        playlistMusic.setSortOrder(maxSortOrder + 1);
        playlistMusic.setAddTime(now); // 设置添加时间
        playlistMusicMapper.updateById(playlistMusic); // 更新歌单音乐信息

        return playlistMusic; // 返回添加成功的歌单音乐信息
    }


    /**
     * 检查音乐信息是否存在
     * @param musicId 音乐ID
     * @return 是否存在
     */
    public boolean checkMusicInPlayListExists(Integer listId, Integer musicId) {
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("music_id", musicId)
                .eq("list_id", listId);
        return playlistMusicMapper.selectCount(queryWrapper) > 0;
    }

    /**
     *  批量添加音乐到歌单。
     *  @param Ids 音乐ID列表
     *  @param listId 歌单ID
     *  //待完成
     * */
    @Override
    public int batchAddMusicToPlaylist(List<Integer> Ids, Integer listId) {
        int count = 0;
        for (Integer musicId : Ids) {
            if (!checkMusicInPlayListExists(listId, musicId)) {
                PlaylistMusic playlistMusic = new PlaylistMusic();
                playlistMusic.setMusicId(musicId);
                playlistMusic.setListId(listId);
                this.save(playlistMusic);
                count++;
            }
        }
        return count;
    }

    /**
     * 从歌单删除音乐。
     * @param musicId 音乐ID
     * @param listId 歌单ID
     * @return PlaylistMusic 删除成功的歌单音乐信息，如果删除失败则返回null
     */
    @Override
    public PlaylistMusic deleteMusicFromPlaylist(Long musicId, Long listId) {
        // 构建查询条件
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("music_id", musicId)
                .eq("list_id", listId);

        // 先根据条件查询记录
        PlaylistMusic playlistMusic = playlistMusicMapper.selectOne(queryWrapper);
        if (playlistMusic == null) {
            // 如果没有找到记录，返回null
            return null;
        }

        // 删除记录
        boolean isSuccess = playlistMusicMapper.delete(queryWrapper) > 0;
        if (isSuccess) {
            // 如果删除成功，返回删除的记录
            return playlistMusic;
        } else {
            // 如果删除失败，返回null
            return null;
        }
    }

    /**
     * 批量从歌单删除音乐。
     * @param musicIds 音乐ID列表
     * @param listId 歌单ID
     * @return List<PlaylistMusic> 删除成功的歌单音乐列表，如果删除失败则返回null
     */
    @Override
    public List<PlaylistMusic> batchDeleteMusicFromPlaylist(List<Long> musicIds, Long listId) {
        // 构建查询条件
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.in("music_id", musicIds)
                .eq("list_id", listId);

        // 根据条件查询记录
        List<PlaylistMusic> playlistMusicList = playlistMusicMapper.selectList(queryWrapper);

        // 删除记录
        int deleteCount = playlistMusicMapper.delete(queryWrapper);
        if (deleteCount > 0) {
            // 如果删除成功，返回删除的记录
            return playlistMusicList;
        } else {
            // 如果删除失败，返回空列表
            return null;
        }
    }

    /**
     * 批量删除指定歌单ID的所有音乐。
     * @param listId 歌单ID
     */
    @Override
    public void batchDeleteMusicFromPlaylist2(Long listId) {
        // 构建查询条件
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", listId);
        // 删除记录
        playlistMusicMapper.delete(queryWrapper);
    }

    /**
     * 根据歌单ID获取音乐ID列表。
     * @param listId 歌单ID
     * @param limit 查询条数限制
     * @return List<Integer> 音乐ID列表
     */
    @Override
    public List<Integer> getMusicsListId(Integer listId, Integer limit) {
        // 构建查询条件
        QueryWrapper<PlaylistMusic> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("list_id", listId)
                .last("LIMIT " + limit);

        // 查询记录
        List<PlaylistMusic> playlistMusicList = playlistMusicMapper.selectList(queryWrapper);

        // 提取music_id并返回
        return playlistMusicList.stream()
                .map(PlaylistMusic::getMusicId)
                .collect(Collectors.toList());
    }


}